/**
 * 需求选项 composable
 * 统一管理需求模块的优先级、类型、来源选项
 * 从接口获取数据，避免硬编码
 * 使用全局共享状态，避免多个组件重复调用接口
 */
import { ref, computed } from 'vue'
import { RequirementPriority } from '@/api/requirements'
import { priorityApi } from '@/api/priority'
import { typeApi } from '@/api/type'
import { sourceApi } from '@/api/source'
import { ModuleType } from '@/types/core'
import { useRequirementStates } from './useRequirementStates'

interface RequirementOptionItem {
  code: string
  name: string
  color: string
  description?: string
  sort_order?: number
}

interface RequirementTypeItem {
  code: string
  name: string
  color?: string
  description?: string
  sort_order?: number
}

interface RequirementSourceItem {
  code: string
  name: string
  color?: string
  description?: string
  sort_order?: number
  is_enabled?: boolean
}

// 全局共享状态（单例模式）
const globalState = {
  // 选项数据
  priorityOptions: ref<RequirementOptionItem[]>([]),
  typeOptions: ref<RequirementTypeItem[]>([]),
  sourceOptions: ref<RequirementSourceItem[]>([]),
  loading: ref(false),
  error: ref<string | null>(null),
  
  // 缓存和去重
  loadingPromise: null as Promise<void> | null,
  lastLoadTime: 0,
  cacheDuration: 5 * 60 * 1000, // 5分钟缓存
  
  // 是否已初始化
  initialized: false
}

// 默认类型选项（作为后备方案，仅在API加载失败时使用）
// 注意：这些值应该与后端默认类型配置保持一致
const defaultTypeOptions: RequirementTypeItem[] = [
  { code: 'functional', name: '功能性需求', color: '#409EFF' },
  { code: 'non_functional', name: '非功能性需求', color: '#67C23A' },
  { code: 'business', name: '业务需求', color: '#E6A23C' },
  { code: 'technical', name: '技术需求', color: '#F56C6C' },
  { code: 'interface', name: '接口需求', color: '#909399' },
  { code: 'performance', name: '性能需求', color: '#606266' },
  { code: 'security', name: '安全需求', color: '#F56C6C' },
  { code: 'usability', name: '可用性需求', color: '#67C23A' }
]

// 默认来源选项（作为后备方案，仅在API加载失败时使用）
// 注意：这些值应该与后端默认来源配置保持一致
const defaultSourceOptions: RequirementSourceItem[] = [
  { code: 'customer', name: '客户', color: '#409EFF' },
  { code: 'stakeholder', name: '利益相关者', color: '#67C23A' },
  { code: 'market_research', name: '市场调研', color: '#E6A23C' },
  { code: 'competitor', name: '竞争对手', color: '#F56C6C' },
  { code: 'internal', name: '内部', color: '#909399' },
  { code: 'regulation', name: '法规要求', color: '#606266' },
  { code: 'technical_debt', name: '技术债务', color: '#F56C6C' }
]

// 默认优先级选项（作为后备方案，仅在API加载失败时使用）
// 注意：这些值应该与后端默认优先级配置保持一致
// 实际使用时应该从优先级管理API获取，而不是硬编码
const defaultPriorityOptions: RequirementOptionItem[] = [
  { code: 'low', name: '低', color: '#67C23A' },
  { code: 'medium', name: '中', color: '#E6A23C' },
  { code: 'high', name: '高', color: '#F56C6C' },
  { code: 'urgent', name: '紧急', color: '#F56C6C' },
  { code: 'critical', name: '严重', color: '#F56C6C' }
]

export function useRequirementOptions() {
  const { statusOptions: requirementStatusOptions, loadStates: loadRequirementStates } = useRequirementStates()
  
  // 使用全局共享状态
  const priorityOptions = globalState.priorityOptions
  const typeOptions = globalState.typeOptions
  const sourceOptions = globalState.sourceOptions
  const loading = globalState.loading
  const error = globalState.error

  // 计算属性：状态选项（从 useRequirementStates 获取）
  const statusOptions = computed(() => {
    return requirementStatusOptions.value.map(s => ({
      code: s.value,
      name: s.label,
      color: s.color || '#909399',
      description: undefined
    }))
  })

  // 计算属性：优先级选项（格式化）
  const formattedPriorityOptions = computed(() => {
    const options = priorityOptions.value.length > 0 ? priorityOptions.value : defaultPriorityOptions
    return options
      .filter(p => p && p.code && p.name) // 过滤掉无效的选项
      .map(p => ({
        value: String(p.code || ''),
        label: String(p.name || ''),
        color: p.color || '#909399',
        description: p.description
      }))
      .filter(opt => opt.value && opt.label) // 再次过滤确保 value 和 label 都不为空
  })

  // 计算属性：类型选项（格式化）
  const formattedTypeOptions = computed(() => {
    const options = typeOptions.value.length > 0 ? typeOptions.value : defaultTypeOptions
    return options
      .filter(t => t && t.code && t.name) // 过滤掉无效的选项
      .map(t => ({
        value: String(t.code || ''),
        label: String(t.name || ''),
        code: t.code,
        color: t.color || '#909399'
      }))
      .filter(opt => opt.value && opt.label) // 再次过滤确保 value 和 label 都不为空
  })

  // 计算属性：来源选项（格式化）
  const formattedSourceOptions = computed(() => {
    const options = sourceOptions.value.length > 0 ? sourceOptions.value : defaultSourceOptions
    return options
      .filter(s => s && s.code && s.name && (s.is_enabled === undefined || s.is_enabled !== false)) // 过滤掉无效的选项和禁用的来源
      .map(s => ({
        value: String(s.code || ''),
        label: String(s.name || ''),
        code: s.code,
        color: s.color || '#909399',
        sort_order: s.sort_order || 0
      }))
      .filter(opt => opt.value && opt.label) // 再次过滤确保 value 和 label 都不为空
      .sort((a: any, b: any) => (a.sort_order || 0) - (b.sort_order || 0)) // 按排序顺序排序
  })

  // 根据代码获取优先级名称
  const getPriorityName = (code: string) => {
    const option = priorityOptions.value.find(p => p.code === code)
    if (option) return option.name
    
    // 如果没有找到，使用默认选项
    const defaultOption = defaultPriorityOptions.find(p => p.code === code)
    if (defaultOption) return defaultOption.name
    
    // 最后尝试匹配枚举值
    const enumKey = Object.keys(RequirementPriority).find(key => RequirementPriority[key as keyof typeof RequirementPriority] === code)
    if (enumKey) {
      const defaultEnumOption = defaultPriorityOptions.find(p => p.code.toLowerCase() === code.toLowerCase())
      return defaultEnumOption?.name || code
    }
    
    return code
  }

  // 根据代码获取优先级颜色
  const getPriorityColor = (code: string) => {
    const option = priorityOptions.value.find(p => p.code === code)
    if (option) return option.color
    
    const defaultOption = defaultPriorityOptions.find(p => p.code === code)
    if (defaultOption) return defaultOption.color
    
    return '#909399'
  }

  // 根据代码获取优先级类型（用于 Element Plus tag type）
  const getPriorityType = (code: string): 'info' | 'success' | 'warning' | 'danger' | 'primary' => {
    const color = getPriorityColor(code)
    // 将颜色转换为 Element Plus 的 tag type
    const colorMap: Record<string, 'info' | 'success' | 'warning' | 'danger' | 'primary'> = {
      '#67C23A': 'success',
      '#E6A23C': 'warning',
      '#F56C6C': 'danger',
      '#409EFF': 'primary',
      '#909399': 'info',
      '#C0C4CC': 'info'
    }
    // 尝试匹配颜色
    for (const [colorKey, type] of Object.entries(colorMap)) {
      if (color.toLowerCase() === colorKey.toLowerCase()) {
        return type
      }
    }
    // 回退到基于代码的默认映射
    const codeMap: Record<string, 'info' | 'success' | 'warning' | 'danger' | 'primary'> = {
      low: 'info',
      medium: 'warning',
      high: 'warning',
      critical: 'danger',
      urgent: 'danger'
    }
    return codeMap[code.toLowerCase()] || 'info'
  }

  // 根据代码获取类型名称
  const getTypeName = (code: string) => {
    const option = typeOptions.value.find(t => t.code === code)
    if (option) return option.name
    
    // 如果没有找到，使用默认选项
    const defaultOption = defaultTypeOptions.find(t => t.code === code)
    if (defaultOption) return defaultOption.name
    
    return code
  }

  // 根据代码获取类型颜色
  const getTypeColor = (code: string) => {
    const option = typeOptions.value.find(t => t.code === code)
    if (option) return option.color || '#909399'
    
    const defaultOption = defaultTypeOptions.find(t => t.code === code)
    if (defaultOption) return defaultOption.color || '#909399'
    
    return '#909399'
  }

  // 根据代码获取来源名称
  const getSourceName = (code: string) => {
    const option = sourceOptions.value.find(s => s.code === code)
    if (option) return option.name
    
    // 如果没有找到，使用默认选项
    const defaultOption = defaultSourceOptions.find(s => s.code === code)
    if (defaultOption) return defaultOption.name
    
    return code
  }

  // 根据代码获取来源颜色
  const getSourceColor = (code: string) => {
    const option = sourceOptions.value.find(s => s.code === code)
    if (option) return option.color || '#909399'
    
    const defaultOption = defaultSourceOptions.find(s => s.code === code)
    if (defaultOption) return defaultOption.color || '#909399'
    
    return '#909399'
  }

  // 获取默认优先级
  const defaultPriority = computed(() => {
    // 优先返回中等优先级，如果没有则返回第一个
    const options = priorityOptions.value.length > 0 ? priorityOptions.value : defaultPriorityOptions
    return options.find(p => p.code === 'medium') || options[0]
  })

  // 加载所有选项数据（带缓存和去重）
  const loadOptions = async (forceRefresh = false) => {
    // 如果正在加载中，返回现有的 Promise，避免重复请求
    if (globalState.loadingPromise && !forceRefresh) {
      return globalState.loadingPromise
    }
    
    // 检查缓存是否有效
    const now = Date.now()
    const isCacheValid = !forceRefresh && 
                        globalState.initialized && 
                        (now - globalState.lastLoadTime) < globalState.cacheDuration &&
                        priorityOptions.value.length > 0 &&
                        typeOptions.value.length > 0 &&
                        sourceOptions.value.length > 0
    
    if (isCacheValid) {
      return Promise.resolve()
    }
    
    // 创建加载 Promise
    const loadPromise = (async () => {
      try {
        loading.value = true
        error.value = null

        // 加载状态数据（使用 useRequirementStates）
        await loadRequirementStates()

        // 尝试从 API 加载优先级选项
        try {
          const response = await priorityApi.getAll('requirement')
          
          if (response.data && response.data.success && response.data.data) {
            const priorities = Array.isArray(response.data.data) ? response.data.data : []
            priorityOptions.value = priorities
              .filter((p: any) => p && (p.code || p.value)) // 过滤掉无效数据
              .map((p: any) => ({
                code: String(p.code || p.value || ''),
                name: String(p.name || p.label || ''),
                color: p.color || '#909399',
                description: p.description,
                sort_order: p.sort_order || 0
              }))
              .filter((p: any) => p.code && p.name) // 再次过滤确保 code 和 name 都不为空
          } else if (response.data && Array.isArray(response.data)) {
            // 如果直接返回数组
            priorityOptions.value = response.data
              .filter((p: any) => p && (p.code || p.value)) // 过滤掉无效数据
              .map((p: any) => ({
                code: String(p.code || p.value || ''),
                name: String(p.name || p.label || ''),
                color: p.color || '#909399',
                description: p.description,
                sort_order: p.sort_order || 0
              }))
              .filter((p: any) => p.code && p.name) // 再次过滤确保 code 和 name 都不为空
          }
        } catch (priorityError) {
          console.warn('从 API 获取需求优先级失败，使用默认选项:', priorityError)
          // 如果 API 调用失败，使用默认选项
          if (priorityOptions.value.length === 0) {
            priorityOptions.value = defaultPriorityOptions
          }
        }

        // 尝试从 API 加载类型选项
        try {
          const typeResponse = await typeApi.getAll(ModuleType.REQUIREMENT)
          
          if (typeResponse.success && typeResponse.data) {
            const types = Array.isArray(typeResponse.data) ? typeResponse.data : []
            typeOptions.value = types
              .filter((t: any) => t && t.code && t.is_enabled !== false) // 过滤掉无效数据和禁用的类型
              .map((t: any) => ({
                code: String(t.code || ''),
                name: String(t.name || ''),
                color: t.color || '#909399',
                description: t.description,
                sort_order: t.sort_order || 0
              }))
              .filter((t: any) => t.code && t.name) // 再次过滤确保 code 和 name 都不为空
              .sort((a: any, b: any) => (a.sort_order || 0) - (b.sort_order || 0)) // 按排序顺序排序
          } else if (Array.isArray(typeResponse)) {
            // 如果直接返回数组
            typeOptions.value = typeResponse
              .filter((t: any) => t && t.code && t.is_enabled !== false) // 过滤掉无效数据和禁用的类型
              .map((t: any) => ({
                code: String(t.code || ''),
                name: String(t.name || ''),
                color: t.color || '#909399',
                description: t.description,
                sort_order: t.sort_order || 0
              }))
              .filter((t: any) => t.code && t.name) // 再次过滤确保 code 和 name 都不为空
              .sort((a: any, b: any) => (a.sort_order || 0) - (b.sort_order || 0)) // 按排序顺序排序
          }
        } catch (typeError) {
          console.warn('从 API 获取需求类型失败，使用默认选项:', typeError)
          // 如果 API 调用失败，使用默认选项
          if (typeOptions.value.length === 0) {
            typeOptions.value = defaultTypeOptions
          }
        }

        // 尝试从 API 加载来源选项
        try {
          const sourceResponse = await sourceApi.getAll(ModuleType.REQUIREMENT)
          
          if (sourceResponse.success && sourceResponse.data) {
            const sources = Array.isArray(sourceResponse.data) ? sourceResponse.data : []
            sourceOptions.value = sources
              .filter((s: any) => s && s.code && s.is_enabled !== false) // 过滤掉无效数据和禁用的来源
              .map((s: any) => ({
                code: String(s.code || ''),
                name: String(s.name || ''),
                color: s.color || '#909399',
                description: s.description,
                sort_order: s.sort_order || 0,
                is_enabled: s.is_enabled !== false
              }))
              .filter((s: any) => s.code && s.name) // 再次过滤确保 code 和 name 都不为空
              .sort((a: any, b: any) => (a.sort_order || 0) - (b.sort_order || 0)) // 按排序顺序排序
          } else if (Array.isArray(sourceResponse)) {
            // 如果直接返回数组
            sourceOptions.value = sourceResponse
              .filter((s: any) => s && s.code && s.is_enabled !== false) // 过滤掉无效数据和禁用的来源
              .map((s: any) => ({
                code: String(s.code || ''),
                name: String(s.name || ''),
                color: s.color || '#909399',
                description: s.description,
                sort_order: s.sort_order || 0,
                is_enabled: s.is_enabled !== false
              }))
              .filter((s: any) => s.code && s.name) // 再次过滤确保 code 和 name 都不为空
              .sort((a: any, b: any) => (a.sort_order || 0) - (b.sort_order || 0)) // 按排序顺序排序
          }
        } catch (sourceError) {
          console.warn('从 API 获取需求来源失败，使用默认选项:', sourceError)
          // 如果 API 调用失败，使用默认选项
          if (sourceOptions.value.length === 0) {
            sourceOptions.value = defaultSourceOptions
          }
        }
        
        // 更新缓存信息
        globalState.lastLoadTime = now
        globalState.initialized = true
      } catch (err: any) {
        console.error('加载需求选项失败:', err)
        error.value = err.message || '加载需求选项失败'
        
        // 使用默认值作为后备（仅在未初始化时）
        if (!globalState.initialized && priorityOptions.value.length === 0) {
          priorityOptions.value = defaultPriorityOptions
        }
        if (!globalState.initialized && typeOptions.value.length === 0) {
          typeOptions.value = defaultTypeOptions
        }
        if (!globalState.initialized && sourceOptions.value.length === 0) {
          sourceOptions.value = defaultSourceOptions
        }
      } finally {
        loading.value = false
        globalState.loadingPromise = null
      }
    })()
    
    // 保存 Promise 以便其他调用可以等待
    globalState.loadingPromise = loadPromise
    
    return loadPromise
  }

  return {
    // 原始数据
    statusOptions,
    typeOptions: computed(() => typeOptions.value),
    sourceOptions: computed(() => sourceOptions.value),
    
    // 格式化后的选项（用于下拉框）- priorityOptions 返回格式化后的数据
    priorityOptions: formattedPriorityOptions,
    formattedPriorityOptions,
    formattedTypeOptions,
    formattedSourceOptions,
    
    // 状态
    loading,
    error,
    
    // 默认值
    defaultPriority,
    
    // 工具函数
    getPriorityName,
    getPriorityColor,
    getPriorityType,
    getTypeName,
    getTypeColor,
    getSourceName,
    getSourceColor,
    
    // 加载方法
    loadOptions
  }
}
